package com.zhijian.medical.enums.diagnose.report;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 前列腺癌报告枚举
 */
@Slf4j
public class ProstateEnum {

    /**
     * 术前辅助治疗
     */
    @AllArgsConstructor
    @Getter
    public enum PreoperativeTreatmentEnum {
        //有 无 未知
        YES("yes", "有"),
        NO("no", "无"),
        UNKNOWN("unknown", "未知");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PreoperativeTreatmentEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 标本名称
     */
    @AllArgsConstructor
    @Getter
    public enum SampleNameEnum {
        //前列腺及双侧精囊腺标本 前列腺癌根治标本 前列腺癌全器官大切片标本
        PROSTATE_AND_BILATERAL_SACRAL_GANGLION("prostate_and_bilateral_sacral_gland", "前列腺及双侧精囊腺标本"),
        PROSTATE_CANCER_RADICAL("prostate_cancer_radical", "前列腺癌根治标本"),
        PROSTATE_CANCER_FULL_ORGAN_LARGE_SLICE("prostate_cancer_full_organ_large_slice", "前列腺癌全器官大切片标本");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 肿瘤部位
     */
    @AllArgsConstructor
    @Getter
    public enum TumorLocationEnum {
        //前纤维组织 左外周带 右外周带 左移行区 右移行区 左中央区 右中央区 双侧外周带 双侧移行区 全叶
        FRONTAL_FIBROUS_TISSUE("frontal_fibrous_tissue", "前纤维组织"),
        LEFT_PERIPHERAL_ZONE("left_peripheral_zone", "左外周带"),
        RIGHT_PERIPHERAL_ZONE("right_peripheral_zone", "右外周带"),
        LEFT_MIGRATION_ZONE("left_migration_zone", "左移行区"),
        RIGHT_MIGRATION_ZONE("right_migration_zone", "右移行区"),
        LEFT_CENTRAL_ZONE("left_central_zone", "左中央区"),
        RIGHT_CENTRAL_ZONE("right_central_zone", "右中央区"),
        BILATERAL_PERIPHERAL_ZONE("bilateral_peripheral_zone", "双侧外周带"),
        BILATERAL_MIGRATION_ZONE("bilateral_migration_zone", "双侧移行区"),
        WHOLE_LEAF("whole_leaf", "全叶");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorLocationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeEnum {
        //前列腺腺泡腺癌
        ADENOCARCINOMA("adenocarcinoma", "前列腺腺泡腺癌", AdenocarcinomaEnum.getList());

        private final String key;
        private final String desc;
        private final List<MappingEnum<String, String>> child;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), e.getChild()))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-前列腺腺泡腺癌
     */
    @AllArgsConstructor
    @Getter
    public enum AdenocarcinomaEnum {
        //前列腺腺泡腺癌 印戒细胞样腺癌 肉瘤样癌 多形性巨细胞腺癌 前列腺上皮内瘤变样癌 前列腺导管腺癌 治疗相关的前列腺神经内分泌癌 前列腺腺鳞癌 前列腺鳞状细胞癌 前列腺腺样囊性（基底细胞）癌
        ADENOCARCINOMA("adenocarcinoma", "前列腺腺泡腺癌"),
        SIGNET_RING_CELL("signet_ring_cell", "印戒细胞样腺癌"),
        SQUAMOUS("squamous", "肉瘤样癌"),
        POLYPOID("polyoid", "多形性巨细胞腺癌"),
        PRECANCER("precancer", "前列腺上皮内瘤变样癌"),
        DUCTAL("ductal", "前列腺导管腺癌"),
        NEUROENDOCRINE("neuroendocrine", "治疗相关的前列腺神经内分泌癌"),
        SQUAMOUS_CELL("squamous_cell", "前列腺腺鳞癌"),
        SQUAMOUS_CELL_CARCINOMA("squamous_cell_carcinoma", "前列腺鳞状细胞癌"),
        ADENOSQUAMOUS("adenosquamous", "前列腺腺样囊性（基底细胞）癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(AdenocarcinomaEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 百分比
     */
    @AllArgsConstructor
    @Getter
    public enum PercentageEnum {

        P0(0, "0"),
        P10(10, "10"),
        P20(20, "20"),
        P30(30, "30"),
        P40(40, "40"),
        P50(50, "50"),
        P60(60, "60"),
        P70(70, "70"),
        P80(80, "80"),
        P90(90, "90"),
        P100(100, "100");

        private final Integer key;
        private final String desc;

        private static final List<MappingEnum<Integer, String>> TEMP_MAPPING = Arrays.stream(PercentageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<Integer, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * Gleason评分
     */
    @AllArgsConstructor
    @Getter
    public enum GleasonScoreEnum {
        //3+3=6分 3+4=7分 3+5=8分 4+3=7分 4+4=8分 4+5=9分 5+3=8分 5+4=9分 5+5=10分 不适用
        THREE_PLUS_THREE("3+3", "3+3=6分"),
        THREE_PLUS_FOUR("3+4", "3+4=7分"),
        THREE_PLUS_FIVE("3+5", "3+5=8分"),
        FOUR_PLUS_THREE("4+3", "4+3=7分"),
        FOUR_PLUS_FOUR("4+4", "4+4=8分"),
        FOUR_PLUS_FIVE("4+5", "4+5=9分"),
        FIVE_PLUS_THREE("5+3", "5+3=8分"),
        FIVE_PLUS_FOUR("5+4", "5+4=9分"),
        FIVE_PLUS_FIVE("5+5", "5+5=10分"),
        NOT_APPLICABLE("not_applicable", "不适用");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(GleasonScoreEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * WHO/ISUP分级分组
     */
    @AllArgsConstructor
    @Getter
    public enum WHOISUPGroupingEnum {
        //1组 2组 3组 4组 5组 不适用
        GROUP_1("group_1", "1组"),
        GROUP_2("group_2", "2组"),
        GROUP_3("group_3", "3组"),
        GROUP_4("group_4", "4组"),
        GROUP_5("group_5", "5组"),
        NOT_APPLICABLE("not_applicable", "不适用");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(WHOISUPGroupingEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 主要成分比例
     */
    @AllArgsConstructor
    @Getter
    public enum MainComponentRatioEnum {
        //无 1% 5% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100%
        NO("no", "无"),
        ONE("1", "1%"),
        FIVE("5", "5%"),
        TEN("10", "10%"),
        TWENTY("20", "20%"),
        THIRTY("30", "30%"),
        FORTY("40", "40%"),
        FIFTY("50", "50%"),
        SIXTY("60", "60%"),
        SEVENTY("70", "70%"),
        EIGHTY("80", "80%"),
        NINETY("90", "90%"),
        HUNDRED("100", "100%");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MainComponentRatioEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 伴有<5%的较高级别成分
     */
    @AllArgsConstructor
    @Getter
    public enum WithLessThan5PercentOfHigherGradeComponentsEnum {
        //无 Gleason4级 Gleason5级
        NO("no", "无"),
        GLEASON_4("gleason_4", "Gleason4级"),
        GLEASON_5("gleason_5", "Gleason5级");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(WithLessThan5PercentOfHigherGradeComponentsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * PSA值分组
     */
    @AllArgsConstructor
    @Getter
    public enum PSAValueGroupingEnum {
        //<10 10-20 <20 >=20 任意
        LESS_THAN_10("less_than_10", "<10"),
        TEN_TO_TWENTY("ten_to_twenty", "10-20"),
        LESS_THAN_20("less_than_20", "<20"),
        GREATER_THAN_OR_EQUAL_TO_20("greater_than_or_equal_to_20", ">=20"),
        ANY("any", "任意");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PSAValueGroupingEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 癌周前列腺组织病变
     */
    @AllArgsConstructor
    @Getter
    public enum ProstateTissueLesionEnum {
        //前列腺结节性増生 前列腺高度上皮内瘤变 前列腺萎缩 前列腺腺病
        PROSTATE_NODULE("prostate_nodule", "前列腺结节性増生"),
        PROSTATE_HIGH_GRADE_INTRAEPITHELIAL_NEOPLASIA("prostate_high_grade_intraepithelial_neoplasia", "前列腺高度上皮内瘤变"),
        PROSTATE_ATROPHY("prostate_atrophy", "前列腺萎缩"),
        PROSTATE_ADENOPATHY("prostate_adenopathy", "前列腺腺病");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ProstateTissueLesionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 前列腺包膜外侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum ProstateExtraprostaticInvasionEnum {
        //无 包膜外脂肪侵犯 包膜外纤维间质侵犯 包膜外纤维间质和脂肪侵犯 无法评估
        NO("no", "无"),
        EXTRAPROSTATIC_FAT("extraprostatic_fat", "包膜外脂肪侵犯"),
        EXTRAPROSTATIC_FIBROUS_INTERSTITIUM("extraprostatic_fibrous_interstitium", "包膜外纤维间质侵犯"),
        EXTRAPROSTATIC_FIBROUS_INTERSTITIUM_AND_FAT("extraprostatic_fibrous_interstitium_and_fat", "包膜外纤维间质和脂肪侵犯"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ProstateExtraprostaticInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 神经侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NeurologicalInvasionEnum {
        //有 无 可疑
        YES("yes", "有"),
        NO("no", "无"),
        SUSPICIOUS("suspicious", "可疑");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeurologicalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 脉管侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum VascularInvasionEnum {
        //有 无 可疑
        YES("yes", "有"),
        NO("no", "无"),
        SUSPICIOUS("suspicious", "可疑");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(VascularInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 精囊腺侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum SeminalVesicleInvasionEnum {
        //左侧 右侧 双侧 无 可疑
        LEFT("left", "左侧"),
        RIGHT("right", "右侧"),
        BOTH("both", "双侧"),
        NO("no", "无"),
        SUSPICIOUS("suspicious", "可疑");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SeminalVesicleInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 尿道侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum UrethralInvasionEnum {
        //无 有 可疑
        NO("no", "无"),
        YES("yes", "有"),
        SUSPICIOUS("suspicious", "可疑");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(UrethralInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 前列腺周围器官侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum PeriprostaticOrganInvasionEnum {
        //无 膀胱 直肠 骨盆壁 其他
        NO("no", "无"),
        BLADDER("bladder", "膀胱"),
        RECTUM("rectum", "直肠"),
        PELVIC_WALL("pelvic_wall", "骨盆壁"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PeriprostaticOrganInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 输精管侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum VasDeferensInvasionEnum {
        //双侧输精管侵犯 左侧输精管侵犯 右侧输精管侵犯 无 可疑
        BOTH("both", "双侧输精管侵犯"),
        LEFT("left", "左侧输精管侵犯"),
        RIGHT("right", "右侧输精管侵犯"),
        NO("no", "无"),
        SUSPICIOUS("suspicious", "可疑");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(VasDeferensInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 淋巴结
     */
    @AllArgsConstructor
    @Getter
    public enum LymphGlandEnum {

        NOT_TRANSFERRED("not_transferred", "未见转移"),
        SEE_TRANSFER("see_transfer", "见转移"),
        GRANULOMATOUS_INFLAMMATION("granulomatous_inflammation", "肉芽肿性炎"),
        ADIPOSE_TISSUE("adipose_tissue", "脂肪组织"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphGlandEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 切缘名称
     */
    @AllArgsConstructor
    @Getter
    public enum MarginsEnum {
        //左尖端下切缘 右尖端下切缘 左基底上切缘 右基底上切缘 环周切缘 双侧输精管切缘 双侧基底上切缘 双侧尖端下切缘 左环周切缘 右环周切缘 其他
        LEFT_TIP("left_tip", "左尖端下切缘"),
        RIGHT_TIP("right_tip", "右尖端下切缘"),
        LEFT_BASE("left_base", "左基底上切缘"),
        RIGHT_BASE("right_base", "右基底上切缘"),
        CIRCUMFERENCE("circumference", "环周切缘"),
        BOTH_VAS("both_vas", "双侧输精管切缘"),
        BOTH_BASE("both_base", "双侧基底上切缘"),
        BOTH_TIP("both_tip", "双侧尖端下切缘"),
        LEFT_CIRCUMFERENCE("left_circumference", "左环周切缘"),
        RIGHT_CIRCUMFERENCE("right_circumference", "右环周切缘"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MarginsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 切缘情况
     */
    @AllArgsConstructor
    @Getter
    public enum MarginsStatusEnum {
        //未见癌残留 癌组织紧靠标本切缘 见癌组织累及 情况无法评估
        NO_CANCER_RESIDUAL("no_cancer_residual", "未见癌残留"),
        CANCER_TISSUE_CLOSE_TO_SPECIMEN_MARGIN("cancer_tissue_close_to_specimen_margin", "癌组织紧靠标本切缘"),
        CANCER_TISSUE_INVOLVED("cancer_tissue_involved", "见癌组织累及"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "情况无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MarginsStatusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 远处转移
     */
    @AllArgsConstructor
    @Getter
    public enum MetastasisEnum {
        //cM0无远处转移 cM1临床证实有远处转移 M1病理证实有远处转移 M1a非区域淋巴结转移 M1b骨转移 M1c其他部位转移，伴/不伴骨转移
        CM0("cm0", "cM0无远处转移"),
        CM1("cm1", "cM1临床证实有远处转移"),
        M1("m1", "M1病理证实有远处转移"),
        M1A("m1a", "M1a非区域淋巴结转移"),
        M1B("m1b", "M1b骨转移"),
        M1C("m1c", "M1c其他部位转移，伴/不伴骨转移");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MetastasisEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * TNM分期-TNM分期
     */
    @AllArgsConstructor
    @Getter
    public enum LesionTnmStageEnum {
        //p yp
        P("p", "p"),
        YP("yp", "yp");


        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LesionTnmStageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-T
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageTEnum {
        //Tx T0  T1a T1b T1c T2a T2b T2c T3a T3b T4
        TX("tx", "Tx"),
        T0("t0", "T0"),
        T1A("t1a", "T1a"),
        T1B("t1b", "T1b"),
        T1C("t1c", "T1c"),
        T2A("t2a", "T2a"),
        T2B("t2b", "T2b"),
        T2C("t2c", "T2c"),
        T3A("t3a", "T3a"),
        T3B("t3b", "T3b"),
        T4("t4", "T4");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageTEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 病理分期-N
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageNEnum {
        //Nx N0 N1
        NX("nx", "Nx"),
        N0("n0", "N0"),
        N1("n1", "N1");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageNEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-M
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageMEnum {
        //Mx cM0 cM1 M1 M1a M1b M1c
        MX("mx", "Mx"),
        CM0("cm0", "cM0"),
        CM1("cm1", "cM1"),
        M1("m1", "M1"),
        M1A("m1a", "M1a"),
        M1B("m1b", "M1b"),
        M1C("m1c", "M1c");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageMEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 错配修复蛋白表达
     */
    @AllArgsConstructor
    @Getter
    public enum MismatchRepairProteinExpressionEnum {
        //表达未见丢失 MLH1表达可见丢失 PMS2表达可见丢失 MSH2表达可见丢失 MSH6表达可见丢失
        EXPRESSION_NOT_LOST("expression_not_lost", "表达未见丢失"),
        MLH1_EXPRESSION_VISIBLE_LOSS("mlh1_expression_visible_loss", "MLH1表达可见丢失"),
        PMS2_EXPRESSION_VISIBLE_LOSS("pms2_expression_visible_loss", "PMS2表达可见丢失"),
        MSH2_EXPRESSION_VISIBLE_LOSS("msh2_expression_visible_loss", "MSH2表达可见丢失"),
        MSH6_EXPRESSION_VISIBLE_LOSS("msh6_expression_visible_loss", "MSH6表达可见丢失");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MismatchRepairProteinExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * MMR状态
     */
    @AllArgsConstructor
    @Getter
    public enum MismatchRepairStatusEnum {
        //错配修复功能缺陷（dMMR） 错配修复功能完整（pMMR）
        DEFECTIVE_MISMATCH_REPAIR("defective_mismatch_repair", "错配修复功能缺陷（dMMR）"),
        PERFECT_MISMATCH_REPAIR("perfect_mismatch_repair", "错配修复功能完整（pMMR）");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MismatchRepairStatusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-表达式
     */
    @AllArgsConstructor
    @Getter
    public enum ImmunohistochemistryExpressionEnum {

        PLUS("+", "+"),
        REDUCE("-", "-"),
        PLUS2("++", "++"),
        PLUS3("+++", "+++"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ImmunohistochemistryExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-其他表达
     */
    @AllArgsConstructor
    @Getter
    public enum ImmunohistochemistryOtherExpressionEnum {

        LYMPHOCYTE_EXPRESSION("lymphocyte_expression", "淋巴细胞表达"),
        VASCULAR_EXPRESSION("vascular_expression", "脉管表达"),
        IMMUNE_CELL_EXPRESSION("immune_cell_expression", "间质免疫细胞表达");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ImmunohistochemistryOtherExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 分子检测-检测方法
     */
    @AllArgsConstructor
    @Getter
    public enum DetectionMethodEnum {
        //FISH PCR  NGS
        FISH("fish", "FISH"),
        PCR("pcr", "PCR"),
        NGS("ngs", "NGS");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(DetectionMethodEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 原位杂交/特殊染色-分析结果
     */
    @AllArgsConstructor
    @Getter
        public enum InSituHybridizationExpressionEnum {

        PLUS("+", "+"),
        REDUCE("-", "-"),
        ZERO("0", "0"),
        PLUS1("1+", "1+"),
        PLUS2("2+", "2+"),
        PLUS3("3+", "3+"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituHybridizationExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }



    /**
     * 分子检测-结果
     */
    @AllArgsConstructor
    @Getter
    public enum MolecularDetectionResultEnum {
        //突变 未突变 未知
        MUTATION("mutation", "突变"),
        NOT_MUTATION("not_mutation", "未突变"),
        UNKNOWN("unknown", "未知");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MolecularDetectionResultEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());


        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 其他送检组织
     */
    @AllArgsConstructor
    @Getter
    public enum OtherInspectionOrganizationsEnum {

        GASTRIC_TISSUE("gastric_tissue", "胃组织"),
        ANASTOMOTIC_SITE_NEAR_END("anastomotic_site_near_end", "吻合口近端"),
        ANASTOMOTIC_SITE_REMOTE_END("anastomotic_site_remote_end", "吻合口远端");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherInspectionOrganizationsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

}
